const api = require("./api.js");

async function login(object) {
  /** object: {
   * phoneNumber, password, role, remeber
   * } */
  const { phoneNumber, password, role, remeber } = object;

  // 构建 formData
  const formData = {
    PhoneNumber: phoneNumber,
    Password: password,
    Role: role
  };

  try {
    const res = await api.getUserInfo(formData);

    if (res.code === 4000000) {
      res.data.password = password;
      res.data.remeber = remeber;

      // 使用 Promise.all 等待两个存储操作完成
      await Promise.all([
        new Promise((resolve, reject) => {
          wx.setStorage({
            key: "userInfo",
            data: res.data,
            success: () => {
              console.log("userInfo 已成功存储到本地");
              resolve();
            },
            fail: reject
          });
        }),
        new Promise((resolve, reject) => {
          wx.setStorage({
            key: "token",
            data: res.data.token,
            success: () => {
              console.log("Token 已成功存储到本地");
              resolve();
            },
            fail: reject
          });
        })
      ]);
      return  { success: true, message: '登录成功' };;
    } else {
      return  { success: false, message: res.msg };;
    }



  } catch (error) {
    console.error("登录失败:", error);
    return { success: false, message: '登录过程中发生异常，请重试' };
  }
};

async function getMaintenanceDetail(object) {
  /** object: {
   * type, phoneNumber, workOrderNumber, batteryNumber,  |||type === 0 新建工单模板 1 通过工单号(workOrderNumber)查询已有工单模板
   * } */
  // 判断用户是新建还是编辑，根据不同的需求调用不同的接口来初始化模板
  if (object.type === 0) {
    // 由于type值为0是新建工单，没有售后工单号，所以此处先将workOrderNumber初始化为空字符串，页面上的“未找到数据” “暂无数据”等
    // 提示会根据此字段进行判断显示
    let workOrder = { workOrderNumber: '' }; // 工单编号
    try {
      // 开始请求电池列表接口 获取一组内全部的电池编号 object.batteryNumber为用户手动\扫码输入的电池编号
      var batteryListRes = await api.dealBatteryNumberList({PhoneNumber: object.phoneNumber, BatteryNumber: object.batteryNumber, });
      // 如果请求失败了就中断整个if (object.type === 0)流程并抛出错误
      if (!batteryListRes.success) throw new Error("获取电池列表失败:" + batteryListRes.msg);

      // 请求成功了 继续读取电池型号并转换为页面显示用的字段
      workOrder.batteryModel = batteryListRes.batteryType // 电池型号
      // 获取电池型号后 进行第一次转换 将获取到的list转换为对象数组
      workOrder.batteryList = batteryListRes.batteryList.map(battery => { // 电池列表
        return {
            battery: battery, //对象的第一个值 电池编号
            userSelected: false,  //对象的第二个值 用于控制页面的单选框状态 false表示默认是未选中的状态
            detectSelected: false, //对象的第三个值，由于运维会进行确认是否受到电池，此值专门给运维控制是否选中
        };
      });

      // 故障原因和退回仓商，请求两个接口后分别将两个res返回内容分别保存下来
      let [failureCauseListRes, manufacturerListRes] = await Promise.all([
        api.getFaultInfo({ PhoneNumber: object.phoneNumber }),
        api.getAllBatteryBackManufacturer({ PhoneNumber: object.phoneNumber }),
      ]);

      // 处理故障原因 将list转为对象数组
      workOrder.failureCauseList = failureCauseListRes.data.map(failureCause => {  
        return {
          failureCause: failureCause.faultName, //第一层对象 此字段为故障原因名
          multiSelected: failureCause.multipleSelections, //第一层对象 此字段为该故障原因是否可以进行单选电池
          userSelected: false, ////第一层对象 此字段为用户是否选中了该故障原因
          batteryList: batteryListRes.batteryList.map(battery => {
            // 不管故障原因能否进行深入的单选电池 此处都要将可单选的电池列表初始化好，保证格式的统一
            return {
              battery: battery, // 用于展示的电池编号
              userSelected: false //用于判断用户有没有选则该故障原因下的这块电池
            };
          })
        };
      });

      //将退回仓商的list转为对象数组 所有的可操作内容都必须为对象，所以以上所有的list都会被转为对象数组
      workOrder.manufacturerList = manufacturerListRes.data.map((manufacturer, index) => { // 全部仓商
        return {
          manufacturer: manufacturer, // 仓商的名称
          userSelected: index === 0 //该字段用于判断用户是否选中了该仓商， 用户还未操作过仓商的情况下默认选中第一个仓商 也就是index为0的那个
        }
      })

      // 以下数据仅做初始化 预留给用户填写的位置
      workOrder.userPostPhotoList = [];  //用户提交的图片
      workOrder.detectPhotoList = [];  //运维提交的图片
      workOrder.userAfterSaleMethod = null // 用户提交的售后方式
      workOrder.userPostDescription = null // 用户提交的描述
      workOrder.manageAfterSaleMethod = null // 管理员变更的售后方式
      workOrder.detectDescription = null // 运维提交的描述
      workOrder.detectFile = null // 运维提交的文件

      return {
        success: true,
        message: '获取数据成功！',
        data: workOrder
      };
      
    } catch (error) {
      console.error('获取维护详情异常:', error);
      return {
        success: false,
        message: error.message
      };
    }
  } else if (object.type === 1) {
    // 页面传来的type值为1 表示用户正准备对已经提交的工单做修改，此处先拿到需要修改的工单的编号
    let workOrder = { workOrderNumber: object.workOrderNumber }; // 工单编号
    try {
      // 通过getMaintenanceDetail接口拿到绝大部分信息
      const res = await api.getMaintenanceDetail({ PhoneNumber: object.phoneNumber, MaintenanceNumber: object.workOrderNumber, });
      //如果getMaintenanceDetail接口返回的code值为4002050，那么开始解析数据
      if (res.code === 4002050) {
        // 获取用户选中的电池列表以及运维确认收到的电池列表
        let batterySelectedList = (Array.isArray(res.data.backBatteryUnite) ? res.data.backBatteryUnite : [])
        const detectSelectedList = (Array.isArray(res.data.getBatteryUnite) ? res.data.getBatteryUnite : [])
        if(Array.isArray(batterySelectedList) && batterySelectedList.length > 0) {
          // 把用户选中的电池列表内的第一块电池作为参数去请求editGetBatteryNumberList来获取完整的电池组列表
          var batteryListRes = await api.editGetBatteryNumberList({PhoneNumber: object.phoneNumber, BatteryNumber: batterySelectedList[0], });
          if (!batteryListRes.success) throw new Error("获取电池列表失败" + batteryListRes.msg);
          workOrder.batteryModel = batteryListRes.batteryType // 电池型号
          workOrder.batteryList = batteryListRes.batteryList.map(battery => { // 电池列表
            return {
                battery: battery, //根据完整的电池组列表来生成电池组名称
                userSelected: batterySelectedList.includes(battery), //根据用户选中的电池列表来判断当前电池是否处于被选中状态
                detectSelected: detectSelectedList.includes(battery), //根据运维选中的电池列表来判断当前电池是否处于已收到状态
            };
          });
          // 由于用户可能是全选了电池列表 此处需要进行判断
          const allChecked = workOrder.batteryList.every(item => item.userSelected === true);

          if (allChecked) {
            // 如果每个电池的userSelected属性都为 true，则将每个电池的userSelected属性设置为 'allTrue'
            //这样页面可以根据该字段在显示时让全选框默认处于勾选状态
            workOrder.batteryList.forEach(item => {
              item.userSelected = 'allTrue';
            });
          }

        }
        // 提取 postImageList，先从接口返回的信息中找到这四个字段
        const imageToExtract = ['faultPhotoFirst', 'faultPhotoSecond', 'faultPhotoThird', 'faultPhotoFourth'];
        workOrder.userPostPhotoList = [];
        // 将这四个字段的内容组合成一个对象数组 供页面操作
        imageToExtract.forEach(key => { // 用户提交的图片
          if ((res.data || {}).hasOwnProperty(key)) {
            if (res.data[key] !== undefined && res.data[key] !== null) {
              workOrder.userPostPhotoList.push({url: res.data[key], key: key});  // url表示图片的路径 key表示是第一张还是第二张还是第几张图片
            }
          }
        })
  
        // 提取 returnImageList 和上方一样
        const imageToReturn = ['detectionResultFirstPhoto', 'detectionResultSecondPhoto', 'detectionResultThirdPhoto', 'detectionResultFourthPhoto'];
        workOrder.detectPhotoList = [];
        imageToReturn.forEach(key => { //运维提交的图片
          if (res.data.hasOwnProperty(key)) {
            if (res.data[key] !== undefined && res.data[key] !== null) {
              workOrder.detectPhotoList.push({url: res.data[key], key: key});
            }
          }
        })

        // 获取全部的故障原因和退回仓商
        let [failureCauseListRes, manufacturerListRes] = await Promise.all([
          api.getFaultInfo({ PhoneNumber: object.phoneNumber }),
          api.getAllBatteryBackManufacturer({ PhoneNumber: object.phoneNumber }),
        ]);

        //遍历全部的故障原因
        workOrder.failureCauseList = failureCauseListRes.data.map(failureCause => {
          // 查找对应的 判断当前故障原因是否被用户选中了 并将这个值先保存起来
          const faultReasonMatch = res.data?.faultReasonList?.find(faultReason => 
            faultReason.reason === failureCause.faultName
          );

          // 此处开始生成新对象
          return {
            failureCause: failureCause.faultName,  // 故障原因的名称
            multiSelected: failureCause.multipleSelections, // 故障原因是否可以进行深入选择电池
            userSelected: !(faultReasonMatch === undefined), // 将之前保存的faultReasonMatch值拿出来，如果用户选了这个原因，那么就写入进去
            batteryList: batteryListRes.batteryList.map(battery => {
              // 生成第二层的电池列表，不管这个原因是否能够进行深入选择电池，都要初始化这个列表
              // 判断用户有没有深入选择了这个电池 并保存判断的结果
              const userSelected = faultReasonMatch && faultReasonMatch.batteryNumberUniteList?.includes(battery) || false;
              
              return {
                battery: battery, //该故障原因下的电池编号
                userSelected: userSelected //将之前保存的值放到这里 用于给页面判断
              };
            })
          };
        });
        
        workOrder.manufacturerList = manufacturerListRes.data.map(manufacturer => { // 全部仓商
          return {
            manufacturer: manufacturer,
            userSelected: manufacturer === res.data.backManufacturer
          }
        })

        workOrder.detectPhoneNumber = res.data.maintenancePhoneNumber // 运维的手机号
        workOrder.userAfterSaleMethod = res.data.faultPostType // 用户提交的售后方式
        workOrder.userPostDescription = res.data.faultPostReason // 用户提交的描述
        workOrder.manageAfterSaleMethod = res.data.updatePostFaultReason // 管理员变更的售后方式
        workOrder.detectDescription = res.data.detectionResult // 运维提交的描述
        workOrder.detectFile = res.data.maintenanceReport // 运维提交的文件

        return {
          success: true,
          message: '获取数据成功！',
          data: workOrder
        };
      } else {
        return {
          success: false,
          message: res.msg || '获取数据失败'
        };
      }
    } catch (error) {
      console.error('获取维护详情异常:', error);
      return {
        success: false,
        message: '网络异常，请稍后再试'
      };
    }
  } else {
    return {
      success: false,
      message: '无效的 type 类型！'
    };
  }
};

async function postMaintenanceDetail(object) {
  /** object: {
   * type, |||type === 0 提交新工单， 1 编辑现有工单
   * workOrder,
   * },
   * |||workOrder为多层嵌套对象，具体结构查阅index.js中的定义 */
  
  // 构建要发送的数据对象
  const backBatteryUnite = object.workOrder.batteryList
    .filter(unit => unit.userSelected || unit.userSelected === 'allTrue')
    .map(unit => unit.battery);

  const faultReasonList = {};
  object.workOrder.failureCauseList.forEach(failureCause => {
    if (failureCause.userSelected) {
      faultReasonList[failureCause.failureCause] = failureCause.multiSelected
        ? failureCause.batteryList.filter(unit => unit.userSelected).map(unit => backBatteryUnite.indexOf(unit.battery))
        : backBatteryUnite.map((_, index) => index);
    }
  });

  const manufacturer = object.workOrder.manufacturerList.find(unit => unit.userSelected).manufacturer

  const formData = {
    MaintenanceNumber: object.workOrder.workOrderNumber,
    PhoneNumber: parseInt(object.workOrder.userPhoneNumber, 10),
    BackBatteryUnite: JSON.stringify(backBatteryUnite),
    FaultReasonList: JSON.stringify(faultReasonList),
    FaultPostType: object.workOrder.userAfterSaleMethod,
    FaultPostReason: object.workOrder.userPostDescription,
    BackManufacturer: manufacturer,
    BatteryModel: object.workOrder.batteryModel
  };

  try {
    const res = object.type === 0 ? await api.postMaintenance(formData) : await api.editMaintenance(formData);

    if (res.code === object.type === 0 ? 4002020 : 4002170 ) {
      let photoNameList = ['faultPhotoFirst', 'faultPhotoSecond', 'faultPhotoThird', 'faultPhotoFourth'];
      const image = object.workOrder.userPostPhotoList.map(item => {
        const index = photoNameList.indexOf(item.key)

        if (index > -1) { // 如果找到了该值
          photoNameList.splice(index, 1); // 从数组中移除该项
        } else if (item.url.startsWith('http://tmp/') || item.url.startsWith('wxfile://')) {
          return {
            ...item
          }
        }
      }).filter(item => item !== undefined);
      let uploadPromises = [];
      let i = 0;
      for ( const photoName of photoNameList ) {
        if (i >= image.length || image.length === 0) {
          const deleteRes = await api.deleteImage({
            MaintenanceNumber: object.type === 0 ? res.data : object.workOrder.workOrderNumber,
            PhotoName: photoName.charAt(0).toUpperCase() + photoName.slice(1)
          })
        } else {
          uploadPromises.push(new Promise((resolve, reject) => {
            wx.uploadFile({
              url: 'https://cxnoblelift.com:8000/AfterSale/PostFaultImage/', // 确保这是正确的上传接口URL
              filePath: image[i].url, // 直接使用原始的本地文件路径
              name: 'MaintenancePhoto', // 固定的文件字段名
              formData: {
                MaintenanceNumber: object.type === 0 ? res.data : object.workOrder.workOrderNumber , // 确保 res.data 是你想要传递的 MaintenanceNumber
                PhotoName: photoName.charAt(0).toUpperCase() + photoName.slice(1) // 使用确定好的照片名称
              },
              success(res) {
                const data = JSON.parse(res.data); // 解析服务器返回的数据
                console.log(`${photoName}张图片上传成功` + res.data);
                resolve(data);
              },
              fail(err) {
                console.error(`${photoName}张图片上传失败`, err);
                reject(err);
              }
            });
          }))
        }
        i ++;
      }

        // 等待所有上传完成
      if (uploadPromises.length > 0) {
        await Promise.all(uploadPromises);
        console.log('所有图片上传完成');
      } else {
        console.log('没有需要上传的图片');
      }

      return { success: true, message: '提交成功！' };
    } else {
      console.error('提交失败:', res.msg);
      return { success: false, message: res.msg };
    }
  } catch (error) {
    console.error('请求异常:', error);
    return { success: false, message: '网络异常！' };
  }
}
// 获取售后列表
const MAINTENANCELIST_CODE = {
  0: { api: api.getUnSendMaintenance, code: 4002100, label: '待发货' },
  1: { api: api.getAllUnDealMaintenanceList, code: 4002030, label: '待回复' },
  2: { api: api.getAllDealMaintenanceList, code: 4002040, label: '已回复' },
};
async function getMaintenanceList(object) {
  /** object: {
   * type, phoneNumber,  |||type === 0 待发货 1 待回复 2 已回复
   * } */
  const { type, phoneNumber } = object;
  // 参数校验
  if (!phoneNumber) {
    return { success: false, message: '手机号不能为空！' };
  }
  const config = MAINTENANCELIST_CODE[type];
  if (!config) {
    return { success: false, message: '无效的 type 类型！' };
  }
  const { api: callApi, code: expectedCode, label } = config;
  const requestData = { PhoneNumber: phoneNumber };
  try {
    const res = await callApi(requestData);
    if (res.code === expectedCode) {
      // 添加 checkStatus 字段
      if (Array.isArray(res.data) && type === 0) {
        res.data = res.data.map(item => ({
          ...item,
          checkStatus: false
        }));
      }
      return {
        success: true,
        data: res.data,
        message: `${label}数据获取成功`
      };
    } else {
      throw new Error(`${label}数据获取失败: ${res.msg}`);
    }
  } catch (error) {
    console.error(`获取${label}维修列表失败:`, error);
    return {
      success: false,
      data: null,
      message: `获取${label}数据失败，请重试`
    };
  }
};
// 操作工单状态 例如将工单发货 将工单取消
const MAINTENANCELIST_STATUS_CHANGE_CODE = {
  0: { api: api.sendAllMaintenance, code: 4002110, label: '发货' },
  1: { api: api.deleteMaintenance, code: 4002120, label: '取消工单' },
};
async function setMaintenanceListStatus(object) {
  /** object: {
   * type, allUnDealMaintenanceList, phoneNumber,  |||type === 0 发货 1 取消工单
   * } */
  const { type, allUnDealMaintenanceList, phoneNumber } = object;
  // 提取选中的工单号
  const selectedItems = allUnDealMaintenanceList
    .filter(item => item.checkStatus)
    .map(item => item.maintenanceNumber);
  if (selectedItems.length === 0) {
    return { success: false, message: '请先选择工单！' };
  }
  const config = MAINTENANCELIST_STATUS_CHANGE_CODE[type];
  if (!config) {
    return { success: false, message: '无效的 type 类型！' };
  }
  const { api: callApi, code: expectedCode, label } = config;
  try {
    const res = await callApi({
      PhoneNumber: phoneNumber,
      MaintenanceList: JSON.stringify(selectedItems),
    });
    if (res.code === expectedCode) {
      return { success: true, message: `${label}成功！` };
    } else {
      return { success: false, message: `${label}失败: ${res.msg}` };
    }
  } catch (error) {
    console.error(`${label}请求失败:`, error);
    return { success: false, message: `请求失败，请稍后再试。` };
  }
};
module.exports = {
  // 登录
  login,
  // 获取售后列表
  getMaintenanceList,
  // 获取售后工单模板
  getMaintenanceDetail,
  // 提交售后
  postMaintenanceDetail,
  // 操作工单状态
  setMaintenanceListStatus,
}